/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package persistencia.controller

import persistencia.conexao.IConexao;
import persistencia.conexao.Conexao;
import groovy.sql.Sql;
import persistencia.controller.ICotacaoController;
import bean.CotacaoPreco;
import bean.CotacaoPrecoMercadorias;
import bean.PedidoCompra;
import bean.PedidoCompraItem;
import bean.BuscaChaveEstrangeira;
import org.postgresql.util.PSQLException;
import java.util.Vector;
import java.util.Date;
import java.util.List;
import java.text.SimpleDateFormat;

/**
 *
 * @author André
 */
class CotacaoController implements ICotacaoController{

    def boolean createCotacaoSemPedido(CotacaoPreco cotacao){

        Sql bd = null;
        try{
            bd = Conexao.getInstance().getConexao();
            
            HashMap<CotacaoPrecoMercadorias> mercadorias = null;
            mercadorias = filtrarMercadorias(cotacao.getCotacaoPrecoMercadoriasList());

            def condicaoCompra = cotacao.getTcondicao_compra_fk();
            //def data = cotacao.getTdata();
            def pedidoGerado = "N"//cotacao.getTpedido_gerado();
            def unidade = cotacao.getTunidade_fk();

            //java.util.Date dataUtil = new java.util.Date();
            java.sql.Date dataSql = new java.sql.Date(new Date().getTime());
            def data = dataSql;

            def sql = "BEGIN;"

            def sqlCotacaoPreco = "insert into " +
            "compras.tcotacao_preco(tunidade_fk, tdata, tcondicao_compra_fk, tpedido_gerado) " + 
            "values(?,?,?,?);"

            sql = sql.concat(sqlCotacaoPreco);
            
            def sqlCotacaoMercadorias = "insert into " + 
            "compras.tcotacao_preco_mercadorias(tsequencia_pk, tcodigo_mercadoria_fk, " + 
            "tcodigo_fornecedor_fk, tpreco_cotacao, tultimo_preco_cotado, tqtde_merc, tdata_cotacao, " + 
            "tnome_mercadoria, tnome_fornecedor) values(?,?,?,?,?,?,?,?,?);";

            //ANTES DE INICIAR AS TRANSAÇÕES FAZER O BEGIN E NO FINAL FAZER O COMMIT
            
            def lista = [unidade, data, condicaoCompra, pedidoGerado];
            
            //bd.execute(sqlCotacaoPreco, listaCotacao);

            int cont = 1;
            for(CotacaoPrecoMercadorias i : mercadorias.values()){

                sql = sql.concat(sqlCotacaoMercadorias);
                
                def codigoFornecedor = i.getTcodigo_fornecedor_fk();
                def codigoMercadoria = i.getTcodigo_mercadoria_fk();
                //def data2 = i.getTdata_cotacao();
                def data2 = data;
                def nomeFornecedor = i.getTnome_fornecedor();
                def nomeMercadoria = i.getTnome_mercadoria();
                def precoCotacao = i.getTpreco_cotacao();
                def qtde = i.getTqtde_merc();
                def ultimoPreco = i.getTultimo_preco_cotado();
                i.setTsequencia_pk(cont);
                def sequencia = i.getTsequencia_pk();

                def listaMercadorias = [sequencia, codigoMercadoria, codigoFornecedor, precoCotacao,
                    ultimoPreco, qtde, data2, nomeMercadoria, nomeFornecedor];
                //bd.execute(sqlCotacaoMercadorias, listaMercadorias);

                lista = lista + listaMercadorias;

                //println "Listas: " + listaCotacao;

                cont++;
            }
            sql = sql.concat("COMMIT;")
            //bd.commit();
            //println "SQL: " + sql;
            //println "VALUES: " + lista;
            bd.execute(sql, lista);
            

            return true;
        }
        catch(PSQLException e){
            System.err.println("PSQLException - CotacaoController.create(): " + e.getMessage());
            e.printStackTrace();
            if(bd != null){
                bd.rollback();
            }
            return false;
        }
        catch(Exception e){
            System.err.println("Exception - CotacaoController.create(): " + e);
            e.printStackTrace();
            if(bd != null){
                bd.rollback();
            }
            return false;
        }
    }

    def Vector<PedidoCompra> createCotacaoComPedido(CotacaoPreco cotacao){

        
        Sql bd = null;
        try{
            bd = Conexao.getInstance().getConexao();

            HashMap<CotacaoPrecoMercadorias> mercadorias = null;
            mercadorias = filtrarMercadorias(cotacao.getCotacaoPrecoMercadoriasList());

            def condicaoCompra = cotacao.getTcondicao_compra_fk();
            //def data = cotacao.getTdata();
            def pedidoGerado = "P"//cotacao.getTpedido_gerado();
            def unidade = cotacao.getTunidade_fk();

            //java.util.Date dataUtil = new java.util.Date();
            java.sql.Date dataSql = new java.sql.Date(new Date().getTime());
            def data = dataSql;

            def sql = "BEGIN;"

            def sqlCotacaoPreco = "insert into " +
            "compras.tcotacao_preco(tunidade_fk, tdata, tcondicao_compra_fk, tpedido_gerado) " +
            "values(?,?,?,?);"

            sql = sql.concat(sqlCotacaoPreco);

            def sqlCotacaoMercadorias = "insert into " +
            "compras.tcotacao_preco_mercadorias(tsequencia_pk, tcodigo_mercadoria_fk, " +
            "tcodigo_fornecedor_fk, tpreco_cotacao, tultimo_preco_cotado, tqtde_merc, tdata_cotacao, " +
            "tnome_mercadoria, tnome_fornecedor) values(?,?,?,?,?,?,?,?,?);";

            //ANTES DE INICIAR AS TRANSAÇÕES FAZER O BEGIN E NO FINAL FAZER O COMMIT

            def lista = [unidade, data, condicaoCompra, pedidoGerado];

            //bd.execute(sqlCotacaoPreco, listaCotacao);

            int cont = 1;
            for(CotacaoPrecoMercadorias i : mercadorias.values()){

                sql = sql.concat(sqlCotacaoMercadorias);

                def codigoFornecedor = i.getTcodigo_fornecedor_fk();
                def codigoMercadoria = i.getTcodigo_mercadoria_fk();
                //def data2 = i.getTdata_cotacao();
                def data2 = data;
                def nomeFornecedor = i.getTnome_fornecedor();
                def nomeMercadoria = i.getTnome_mercadoria();
                def precoCotacao = i.getTpreco_cotacao();
                def qtde = i.getTqtde_merc();
                def ultimoPreco = i.getTultimo_preco_cotado();
                i.setTsequencia_pk(cont);
                def sequencia = i.getTsequencia_pk();

                def listaMercadorias = [sequencia, codigoMercadoria, codigoFornecedor, precoCotacao,
                    ultimoPreco, qtde, data2, nomeMercadoria, nomeFornecedor];
                //bd.execute(sqlCotacaoMercadorias, listaMercadorias);

                lista = lista + listaMercadorias;

                //println "Listas: " + listaCotacao;

                cont++;
            }
            sql = sql.concat("COMMIT;")
            //bd.commit();
            //println "SQL: " + sql;
            //println "VALUES: " + lista;
            bd.execute(sql, lista);
            
            def sqlPk = "SELECT currval('compras.tcotacao_preco_tcodigo_pk_seq');";

            Integer codigo;
            
            bd.eachRow(sqlPk){
                codigo = new Integer(it.toRowResult().getAt("currval").intValue());
            }
            cotacao.setTcodigo_pk(codigo)
            cotacao.setCotacaoPrecoMercadoriasList(new Vector(mercadorias.values()))
            HashMap<PedidoCompra> pedidos = criarPedidos(cotacao)

            return new Vector(pedidos.values());
        }
        catch(PSQLException e){
            System.err.println("PSQLException - CotacaoController.create(): " + e.getMessage());
            e.printStackTrace();
            if(bd != null){
                bd.rollback();
            }
            return false;
        }
        catch(Exception e){
            System.err.println("Exception - CotacaoController.create(): " + e);
            e.printStackTrace();
            if(bd != null){
                bd.rollback();
            }
            return false;
        }
    }

    def Vector<CotacaoPreco> readCotacao(String data, String nomeFornecedor){

        try{
            Sql bd = Conexao.getInstance().getConexao();

            def sqlMae = "SELECT * FROM compras.tcotacao_preco WHERE tdata = " + "'" + data + "'";
            Vector<CotacaoPreco> listMae = new Vector<CotacaoPreco>();
            Vector<CotacaoPrecoMercadorias> listFilha = new Vector<CotacaoPrecoMercadorias>();
            Vector<CotacaoPreco> list = new Vector<CotacaoPreco>();

            bd.eachRow(sqlMae){
                CotacaoPreco cot = new CotacaoPreco(it.toRowResult());
                //println it.toRowResult().getAt("tdata").getClass();
                SimpleDateFormat s = new SimpleDateFormat();
                s.applyPattern("dd/MM/yyyy");
                cot.setTdata(s.format(it.toRowResult().getAt("tdata")));
                listMae.add(cot);
            }

            for(CotacaoPreco i : listMae){
                def sqlFilha = "SELECT * FROM compras.tcotacao_preco_mercadorias WHERE " +
                               "tcotacao_preco_fpk = " + i.getTcodigo_pk() + " AND EXISTS " +
                               "(SELECT * FROM compras.tcotacao_preco_mercadorias WHERE " +
                               "tcotacao_preco_fpk = " + i.getTcodigo_pk() + " AND " +
                               "tnome_fornecedor ~* " + "'" + nomeFornecedor + "')";
                bd.eachRow(sqlFilha){
                    CotacaoPrecoMercadorias merc = new CotacaoPrecoMercadorias(it.toRowResult());
                    SimpleDateFormat s = new SimpleDateFormat();
                    s.applyPattern("dd/MM/yyyy");
                    println merc.getTcotacao_preco_fpk() + " / " + merc.getTsequencia_pk()
                    merc.setTdata_cotacao(s.format(it.toRowResult().getAt("tdata_cotacao")))

                    //result << it.toRowResult()
                    listFilha.add(merc);
                }
                println "trocou"
                
                i.setCotacaoPrecoMercadoriasList(new Vector(listFilha));                
                
                listFilha.clear();
            }
            for(CotacaoPreco i : listMae){
                if(!i.getCotacaoPrecoMercadoriasList().isEmpty()){
                    list.add(i)
                }
            }

            if(list.isEmpty()){
                CotacaoPrecoMercadorias m = new CotacaoPrecoMercadorias();
                Vector<CotacaoPrecoMercadorias> l = new Vector<CotacaoPrecoMercadorias>();
                l.add(m);
                CotacaoPreco c = new CotacaoPreco();
                c.setCotacaoPrecoMercadoriasList(l);
                list.add(c);
            }    

            return list;
        }
        catch(Exception e){
            e.printStackTrace();
            return null;
        }
    }

    def CotacaoPreco readCotacaoPorId(Integer codigoCotacao){

        try{
            Sql bd = Conexao.getInstance().getConexao();

            def sqlMae = "SELECT * FROM compras.tcotacao_preco WHERE tcodigo_pk = " + codigoCotacao;
            def sqlFilha = "SELECT * FROM compras.tcotacao_preco_mercadorias WHERE " +
                      "tcotacao_preco_fpk = " + codigoCotacao;
        
            Vector<CotacaoPrecoMercadorias> list = new Vector<CotacaoPrecoMercadorias>();
            CotacaoPreco cot = new CotacaoPreco();
        
            bd.eachRow(sqlFilha){
                //result << it.toRowResult()
                list.add(new CotacaoPrecoMercadorias(it.toRowResult()));
            }

            if(list.isEmpty()){
                CotacaoPrecoMercadorias m = new CotacaoPrecoMercadorias();
                list.add(m);
            }

            bd.eachRow(sqlMae){
                cot = new CotacaoPreco(it.toRowResult());
                //println "SQL mae: " + cot;
            }

            cot.setCotacaoPrecoMercadoriasList(list);

            return cot;
        }
        catch(Exception e){
            e.printStackTrace();
            return null;
        }
    }

    def Vector<PedidoCompra> updateCotacaoComPedido(CotacaoPreco cotacao){
        //se a cotação está com o status de PedidoCompra pendente, nada pode ser alterado
        Sql bd = null;
        try{
            bd = Conexao.getInstance().getConexao();

            def codigo = cotacao.getTcodigo_pk();
            def data;
            //PRIMEIRA COISA A SE FAZER É VERIFICAR O STATUS DA COTAÇÃO, SE GEROU OU NÃO PEDIDO OU SE ESTÁ PENDENTE
            def sqlVerificaStatus = "SELECT * FROM compras.tcotacao_preco WHERE tcodigo_pk = " + codigo;
            CotacaoPreco cot = null;
            bd.eachRow(sqlVerificaStatus){
                cot = new CotacaoPreco(it.toRowResult());
                data = it.toRowResult().getAt("tdata");
            }
            //verifica se a cotacao foi deletada ou se já foi gerado um Pedido a partir da Cotação
            if( (cot == null) || (cot.getTpedido_gerado().equalsIgnoreCase("S")) ){
                Vector<PedidoCompra> vetorPedidos = new Vector<PedidoCompra>();
                ArrayList<PedidoCompraItem> vetorItens = new ArrayList<PedidoCompraItem>();
                PedidoCompraItem item = new PedidoCompraItem();
                vetorItens.add(item);
                PedidoCompra ped = new PedidoCompra();
                ped.setPedidoCompraItemList(vetorItens);
                vetorPedidos.add(ped);

                return vetorPedidos;
            }
            //o Pedido está pendente, logo nenhuma alteracao na cotacao pode ser feita
            else if(cot.getTpedido_gerado().equalsIgnoreCase("P")){

                CotacaoPreco cotacaoCorreta = readCotacaoPorId(codigo);                
                HashMap<PedidoCompra> pedidos = criarPedidos(cotacaoCorreta)

                return new Vector(pedidos.values());
            }

            HashMap<CotacaoPrecoMercadorias> mercadorias = null;
            mercadorias = filtrarMercadorias(cotacao.getCotacaoPrecoMercadoriasList());

            def unidade = cotacao.getTunidade_fk();
            def condicaoCompra = cotacao.getTcondicao_compra_fk();
            //apesar de tratar no BPEL, por segurança, trata-se aqui tb
            //def pedidoGerado = "N";     //cotacao.getTpedido_gerado();
            def pedidoGerado = "P"      //cotacao.getTpedido_gerado();

            def sql = "BEGIN;"

            //ANTES FAZ O DELETE DE TODOS OS REGISTROS FILHOS
            def sqlDeleteFilhos = "DELETE FROM compras.tcotacao_preco_mercadorias WHERE tcotacao_preco_fpk = ?;";
            sql = sql.concat(sqlDeleteFilhos);

            def sqlCotacaoPreco = "UPDATE compras.tcotacao_preco SET " +
                    "tunidade_fk = ?, tcondicao_compra_fk = ?, tpedido_gerado = ? " +
                    "WHERE tcodigo_pk = ?;"

            sql = sql.concat(sqlCotacaoPreco);

            def sqlCotacaoMercadorias = "INSERT into " +
                    "compras.tcotacao_preco_mercadorias(tcotacao_preco_fpk, tsequencia_pk, tcodigo_mercadoria_fk, " +
                    "tcodigo_fornecedor_fk, tpreco_cotacao, tultimo_preco_cotado, tqtde_merc, tdata_cotacao, " +
                    "tnome_mercadoria, tnome_fornecedor) values(?,?,?,?,?,?,?,?,?,?);";

            def lista = [codigo, unidade, condicaoCompra, pedidoGerado, codigo];

            int cont = 1;
            for(CotacaoPrecoMercadorias i : mercadorias.values()){

                sql = sql.concat(sqlCotacaoMercadorias);

                def codigoFornecedor = i.getTcodigo_fornecedor_fk();
                def codigoMercadoria = i.getTcodigo_mercadoria_fk();
                def data2 = data;
                def nomeFornecedor = i.getTnome_fornecedor();
                def nomeMercadoria = i.getTnome_mercadoria();
                def precoCotacao = i.getTpreco_cotacao();
                def qtde = i.getTqtde_merc();
                def ultimoPreco = i.getTultimo_preco_cotado();
                i.setTsequencia_pk(cont);
                def sequencia = i.getTsequencia_pk();

                def listaMercadorias = [codigo, sequencia, codigoMercadoria, codigoFornecedor, precoCotacao,
                    ultimoPreco, qtde, data2, nomeMercadoria, nomeFornecedor];

                lista = lista + listaMercadorias;

                cont++;
            }
            sql = sql.concat("COMMIT;")
            bd.execute(sql, lista);

            cotacao.setCotacaoPrecoMercadoriasList(new Vector(mercadorias.values()))
            HashMap<PedidoCompra> pedidos = criarPedidos(cotacao)

            return new Vector(pedidos.values());
        }
        catch(PSQLException e){
            System.err.println("PSQLException - CotacaoController.updateCotacao(): " + e.getMessage());
            e.printStackTrace();
            if(bd != null){
                bd.rollback();
            }
            Vector<PedidoCompra> vetorPedidos = new Vector<PedidoCompra>();
            ArrayList<PedidoCompraItem> vetorItens = new ArrayList<PedidoCompraItem>();
            PedidoCompraItem item = new PedidoCompraItem();
            vetorItens.add(item);
            PedidoCompra ped = new PedidoCompra();
            ped.setPedidoCompraItemList(vetorItens);
            vetorPedidos.add(ped);

            return vetorPedidos;
        }
        catch(Exception e){
            System.err.println("Exception - CotacaoController.updateCotacao(): " + e);
            e.printStackTrace();
            if(bd != null){
                bd.rollback();
            }
            Vector<PedidoCompra> vetorPedidos = new Vector<PedidoCompra>();
            ArrayList<PedidoCompraItem> vetorItens = new ArrayList<PedidoCompraItem>();
            PedidoCompraItem item = new PedidoCompraItem();
            vetorItens.add(item);
            PedidoCompra ped = new PedidoCompra();
            ped.setPedidoCompraItemList(vetorItens);
            vetorPedidos.add(ped);

            return vetorPedidos;
        }        
    }

    def boolean updateCotacao(CotacaoPreco cotacao){

        Sql bd = null;
        try{
            bd = Conexao.getInstance().getConexao();

            println "Update Cotacao antes> " + cotacao.getCotacaoPrecoMercadoriasList();

            def codigo = cotacao.getTcodigo_pk();
            def data;
            //PRIMEIRA COISA A SE FAZER É VERIFICAR O STATUS DA COTAÇÃO, SE GEROU OU NÃO PEDIDO
            def sqlVerificaStatus = "SELECT * FROM compras.tcotacao_preco WHERE tcodigo_pk = " + codigo;
            CotacaoPreco cot = null;
            bd.eachRow(sqlVerificaStatus){
                cot = new CotacaoPreco(it.toRowResult());
                data = it.toRowResult().getAt("tdata");
            }
            //verifica se a cotacao foi deletada ou se já foi gerado um Pedido a partir da Cotação
            if( (cot == null) || (cot.getTpedido_gerado().equalsIgnoreCase("S")) ){
                return false;
            }
            //o Pedido está pendente, logo nenhuma alteracao na cotacao pode ser feita
            else if(cot.getTpedido_gerado().equalsIgnoreCase("P")){
                cotacao = readCotacaoPorId(codigo);
                cotacao.setTpedido_gerado("S");     //nada pode ser alterado, apenas esse campo
            }

            println "Update Cotacao depois> " + cotacao.getCotacaoPrecoMercadoriasList();
            HashMap<CotacaoPrecoMercadorias> mercadorias = null;
            mercadorias = filtrarMercadorias(cotacao.getCotacaoPrecoMercadoriasList());
            
            def unidade = cotacao.getTunidade_fk();            
            def condicaoCompra = cotacao.getTcondicao_compra_fk();
            //apesar de tratar no BPEL, por segurança, trata-se aqui tb
            //def pedidoGerado = "N";     //cotacao.getTpedido_gerado();
            def pedidoGerado = cotacao.getTpedido_gerado();
        
            def sql = "BEGIN;"

            //ANTES FAZ O DELETE DE TODOS OS REGISTROS FILHOS            
            def sqlDeleteFilhos = "DELETE FROM compras.tcotacao_preco_mercadorias WHERE tcotacao_preco_fpk = ?;";
            sql = sql.concat(sqlDeleteFilhos);
            
            def sqlCotacaoPreco = "UPDATE compras.tcotacao_preco SET " +
                    "tunidade_fk = ?, tcondicao_compra_fk = ?, tpedido_gerado = ? " +
                    "WHERE tcodigo_pk = ?;"
        
            sql = sql.concat(sqlCotacaoPreco);
        
            def sqlCotacaoMercadorias = "INSERT into " +
                    "compras.tcotacao_preco_mercadorias(tcotacao_preco_fpk, tsequencia_pk, tcodigo_mercadoria_fk, " +
                    "tcodigo_fornecedor_fk, tpreco_cotacao, tultimo_preco_cotado, tqtde_merc, tdata_cotacao, " +
                    "tnome_mercadoria, tnome_fornecedor) values(?,?,?,?,?,?,?,?,?,?);";
        
            def lista = [codigo, unidade, condicaoCompra, pedidoGerado, codigo];

            int cont = 1;
            for(CotacaoPrecoMercadorias i : mercadorias.values()){
        
                sql = sql.concat(sqlCotacaoMercadorias);
        
                def codigoFornecedor = i.getTcodigo_fornecedor_fk();
                def codigoMercadoria = i.getTcodigo_mercadoria_fk();
                def data2 = data;
                def nomeFornecedor = i.getTnome_fornecedor();
                def nomeMercadoria = i.getTnome_mercadoria();
                def precoCotacao = i.getTpreco_cotacao();
                def qtde = i.getTqtde_merc();
                def ultimoPreco = i.getTultimo_preco_cotado();
                i.setTsequencia_pk(cont);
                def sequencia = i.getTsequencia_pk();
        
                def listaMercadorias = [codigo, sequencia, codigoMercadoria, codigoFornecedor, precoCotacao,
                    ultimoPreco, qtde, data2, nomeMercadoria, nomeFornecedor];
                
                lista = lista + listaMercadorias;
        
                cont++;
            }
            sql = sql.concat("COMMIT;")
            bd.execute(sql, lista);       
        
            return true;
        }
        catch(PSQLException e){
            System.err.println("PSQLException - CotacaoController.updateCotacao(): " + e.getMessage());
            e.printStackTrace();
            if(bd != null){
                bd.rollback();
            }
            return false;
        }
        catch(Exception e){
            System.err.println("Exception - CotacaoController.updateCotacao(): " + e);
            e.printStackTrace();
            if(bd != null){
                bd.rollback();
            }
            return false;
        }
    }


    def boolean deleteCotacao(Integer codigoCotacao){

        Sql bd = null;
        try{
            bd = Conexao.getInstance().getConexao();

            def sql = "BEGIN;"

            def sqlFilha = "DELETE FROM compras.tcotacao_preco_mercadorias WHERE tcotacao_preco_fpk = ?;";
            sql = sql.concat(sqlFilha);
            def sqlMae = "DELETE FROM compras.tcotacao_preco WHERE tcodigo_pk = ?;";
            sql = sql.concat(sqlMae);

            sql = sql.concat("COMMIT;")
            
            def lista = [codigoCotacao, codigoCotacao];

            bd.execute(sql, lista);
            return true;
                
        }
        catch(Exception e){
            e.printStackTrace();
            if(bd != null){
                //bd.rollback();
                bd.execute("ROLLBACK;")
            }
            return false;
        }
    }

    def HashMap<CotacaoPrecoMercadorias> filtrarMercadorias(List<CotacaoPrecoMercadorias> mercadoriasArray){

        //ArrayList<CotacaoPrecoMercadorias> cotacoesPedidos = new ArrayList<CotacaoPrecoMercadorias>();
        HashMap<Integer, CotacaoPrecoMercadorias> map = new HashMap<Integer, CotacaoPrecoMercadorias>();

        //Bubble sort para ordenar por mercadoria
        for (int i = 0; i < mercadoriasArray.size(); i++) {
            for (int j = 1; j < mercadoriasArray.size(); j++) {
                if (mercadoriasArray.get(j-1).getTcodigo_mercadoria_fk() <
                    mercadoriasArray.get(i).getTcodigo_mercadoria_fk()) {
                    //swap(a, j, j + 1);
                    CotacaoPrecoMercadorias temp = mercadoriasArray.get(j);
                    mercadoriasArray.set(j,mercadoriasArray.get(j-1));
                    mercadoriasArray.set(j-1, temp);
                }
            }
        }

        for(int i = 0; i < mercadoriasArray.size(); i++){
            if(map.containsKey(mercadoriasArray.get(i).getTcodigo_mercadoria_fk())){
                CotacaoPrecoMercadorias merc = map.get(mercadoriasArray.get(i).getTcodigo_mercadoria_fk());
                System.out.println("Do mapa: " + merc.getTpreco_cotacao());
                if(mercadoriasArray.get(i).getTpreco_cotacao().compareTo(merc.getTpreco_cotacao()) < 0){
                    System.out.println("Setou: " + mercadoriasArray.get(i).getTpreco_cotacao());
                    map.put(mercadoriasArray.get(i).getTcodigo_mercadoria_fk(), mercadoriasArray.get(i));
                }
            }
            else{
                System.out.println("ELSE: " + mercadoriasArray.get(i).getTpreco_cotacao());
                map.put(mercadoriasArray.get(i).getTcodigo_mercadoria_fk(), mercadoriasArray.get(i));
            }
        }

        //for(CotacaoPrecoMercadorias i : cotacoesPedidos){
        for(CotacaoPrecoMercadorias i : map.values()){
            System.out.println("A pedir: " + i.getTnome_mercadoria() + " / " + i.getTnome_fornecedor());
        }
        return map;
    }

    def Vector<BuscaChaveEstrangeira> searchUnidadePorId(Integer codigo) {
        try{
            Sql bd = Conexao.getInstance().getConexao();

            def sql = "SELECT * FROM unidades.tunidade WHERE " +
                      "tcod_unidade_pk = " + codigo;
            
            Vector<BuscaChaveEstrangeira> list = new Vector<BuscaChaveEstrangeira>();

            bd.eachRow(sql){
                Map m = it.toRowResult();
                BuscaChaveEstrangeira fk = new BuscaChaveEstrangeira();
                fk.setId(m.tcod_unidade_pk);
                fk.setNome(m.tnome_fantasia);

                list.add(fk);
            }
            if(list.isEmpty())
            return null;

            return list;
        }
        catch(Exception e){
            e.printStackTrace();
            return null;
        }
    }

    def Vector<BuscaChaveEstrangeira> searchUnidadePorNome(String nomeFantasia) {
        try{
            Sql bd = Conexao.getInstance().getConexao();

            def sql = "SELECT * FROM unidades.tunidade WHERE " +
                      "tnome_fantasia ~* " + "'" + nomeFantasia + "'";
            //def sql = "SELECT * FROM compras.tfornecedor";

            Vector<BuscaChaveEstrangeira> list = new Vector<BuscaChaveEstrangeira>();

            bd.eachRow(sql){
                Map m = it.toRowResult();
                BuscaChaveEstrangeira fk = new BuscaChaveEstrangeira();
                fk.setId(m.tcod_unidade_pk);
                fk.setNome(m.tnome_fantasia);

                list.add(fk);
            }
            if(list.isEmpty())
            return null;

            return list;
        }
        catch(Exception e){
            e.printStackTrace();
            return null;
        }
    }

    def Vector<BuscaChaveEstrangeira> searchCondicaoPorId(Integer codigo) {
        try{
            Sql bd = Conexao.getInstance().getConexao();

            def sql = "SELECT * FROM compras.tcondicao_compra WHERE " +
                      "tcodigo_pk = " + codigo;
            
            Vector<BuscaChaveEstrangeira> list = new Vector<BuscaChaveEstrangeira>();

            bd.eachRow(sql){
                Map m = it.toRowResult();
                BuscaChaveEstrangeira fk = new BuscaChaveEstrangeira();
                fk.setId(m.tcodigo_pk);
                fk.setNome(m.tdescricao);

                list.add(fk);
            }
            if(list.isEmpty())
            return null;

            return list;
        }
        catch(Exception e){
            e.printStackTrace();
            return null;
        }
    }

    def Vector<BuscaChaveEstrangeira> searchCondicaoPorNome(String descricao) {
        try{
            Sql bd = Conexao.getInstance().getConexao();

            def sql = "SELECT * FROM compras.tcondicao_compra WHERE " +
                      "tdescricao ~* " + "'" + descricao + "'";
            //def sql = "SELECT * FROM compras.tfornecedor";

            Vector<BuscaChaveEstrangeira> list = new Vector<BuscaChaveEstrangeira>();

            bd.eachRow(sql){
                Map m = it.toRowResult();
                BuscaChaveEstrangeira fk = new BuscaChaveEstrangeira();
                fk.setId(m.tcodigo_pk);
                fk.setNome(m.tdescricao);

                list.add(fk);
            }
            if(list.isEmpty())
            return null;

            return list;
        }
        catch(Exception e){
            e.printStackTrace();
            return null;
        }
    }

    def Vector<BuscaChaveEstrangeira> searchMercadoriaPorId(Integer codigo) {
        try{
            Sql bd = Conexao.getInstance().getConexao();

            def sql = "SELECT * FROM logistica.tmercadoria WHERE " +
                      "tcodigo_pk = " + codigo;
            //def sql = "SELECT * FROM compras.tfornecedor";

            Vector<BuscaChaveEstrangeira> list = new Vector<BuscaChaveEstrangeira>();

            bd.eachRow(sql){
                Map m = it.toRowResult();
                BuscaChaveEstrangeira fk = new BuscaChaveEstrangeira();
                fk.setId(m.tcodigo_pk);
                fk.setNome(m.tnome_mercadoria);

                list.add(fk);
            }
            if(list.isEmpty())
            return null;

            return list;
        }
        catch(Exception e){
            e.printStackTrace();
            return null;
        }
    }

    def Vector<BuscaChaveEstrangeira> searchMercadoriaPorNome(String nome) {
        try{
            Sql bd = Conexao.getInstance().getConexao();

            def sql = "SELECT * FROM logistica.tmercadoria WHERE " +
                      "tnome_mercadoria ~* " + "'" + nome + "'";
            //def sql = "SELECT * FROM compras.tfornecedor";

            Vector<BuscaChaveEstrangeira> list = new Vector<BuscaChaveEstrangeira>();

            bd.eachRow(sql){
                Map m = it.toRowResult();
                BuscaChaveEstrangeira fk = new BuscaChaveEstrangeira();
                fk.setId(m.tcodigo_pk);
                fk.setNome(m.tnome_mercadoria);

                list.add(fk);
            }
            if(list.isEmpty())
            return null;

            return list;
        }
        catch(Exception e){
            e.printStackTrace();
            return null;
        }
    }

    def Vector<BuscaChaveEstrangeira> searchFornecedorPorId(Integer codigo) {
        try{
            Sql bd = Conexao.getInstance().getConexao();

            def sql = "SELECT * FROM compras.tfornecedor WHERE " +
                      "tcod_fornecedor_pk = " + codigo;
            //def sql = "SELECT * FROM compras.tfornecedor";

            Vector<BuscaChaveEstrangeira> list = new Vector<BuscaChaveEstrangeira>();

            bd.eachRow(sql){
                Map m = it.toRowResult();
                BuscaChaveEstrangeira fk = new BuscaChaveEstrangeira();
                fk.setId(m.tcod_fornecedor_pk);
                fk.setNome(m.tnome_fantasia);

                list.add(fk);
            }
            if(list.isEmpty())
            return null;

            return list;
        }
        catch(Exception e){
            e.printStackTrace();
            return null;
        }
    }

    def Vector<BuscaChaveEstrangeira> searchFornecedorPorNome(String nome) {
        try{
            Sql bd = Conexao.getInstance().getConexao();

            def sql = "SELECT * FROM compras.tfornecedor WHERE " +
                      "tnome_fantasia ~* " + "'" + nome + "'";
            //def sql = "SELECT * FROM compras.tfornecedor";

            Vector<BuscaChaveEstrangeira> list = new Vector<BuscaChaveEstrangeira>();

            bd.eachRow(sql){
                Map m = it.toRowResult();
                BuscaChaveEstrangeira fk = new BuscaChaveEstrangeira();
                fk.setId(m.tcod_fornecedor_pk);
                fk.setNome(m.tnome_fantasia);

                list.add(fk);
            }
            if(list.isEmpty())
            return null;

            return list;
        }
        catch(Exception e){
            e.printStackTrace();
            return null;
        }
    }

    def HashMap<PedidoCompra> criarPedidos(CotacaoPreco cotacao){

        //código do Fornecedor - Pedido de Compra para esse Fornecedor
        HashMap<Integer, PedidoCompra> map = new HashMap<Integer, PedidoCompra>();

        for(CotacaoPrecoMercadorias i : cotacao.getCotacaoPrecoMercadoriasList()){
            Integer qtde = i.getTqtde_merc();
            BigDecimal preco = i.getTpreco_cotacao();
            BigDecimal valor = preco.multiply(new BigDecimal(qtde))

            PedidoCompraItem item = new PedidoCompraItem();
            item.setTcod_merc_fpk(i.getTcodigo_mercadoria_fk())
            item.setTcod_pedido_fpk(-1) //só é setado valor de verdade na hora do INSERT
            item.setTcodigo_original("")
            item.setTdesconto_ped_perc(BigDecimal.ZERO)
            item.setTdesconto_ped_valor(BigDecimal.ZERO)
            item.setTpreco_compra(preco)
            item.setTpreco_compra_liquido(preco)
            item.setTqtde_chegada(-1)
            item.setTqtde_compra(qtde)
            item.setTvalor_liquido(valor)
            item.setTvalor_total(valor)

            Integer codFornecedor = i.getTcodigo_fornecedor_fk();

            //se contém, atualiza a lista de Itens do Pedido
            if(map.containsKey(codFornecedor)){
                PedidoCompra pedido = map.get(codFornecedor);
                pedido.setTsaldo_a_entregar(pedido.getTsaldo_a_entregar().add(valor))
                pedido.setTvalor_bruto(pedido.getTvalor_bruto().add(valor))
                pedido.setTvalor_liquido_pedido(pedido.getTvalor_liquido_pedido().add(valor))
                pedido.setTvalor_pedido(pedido.getTvalor_pedido().add(valor))
                pedido.setTqtde_itens_merc(++pedido.getTqtde_itens_merc())
                pedido.getPedidoCompraItemList().add(item)
                
                //se nao funcionar, fazer o map.put()
            }
            else{
                PedidoCompra pedidoCompra = new PedidoCompra();
                pedidoCompra.setTacordo_frete("");
                pedidoCompra.setTcod_fornecedor_fk(codFornecedor);
                pedidoCompra.setTcodigo_pk(-1);     //só é setado valor de verdade na hora do INSERT
                pedidoCompra.setTcondicao_compra_fk(cotacao.getTcondicao_compra_fk());
                pedidoCompra.setTcotacao_fk(cotacao.getTcodigo_pk());
                pedidoCompra.setTdata("01/01/2001");    //só é setado valor de verdade na hora do INSERT
                pedidoCompra.setTdata_previsao_faturamento("06/01/2001");   //só é setado valor de verdade na hora do INSERT
                pedidoCompra.setTdesconto_perc(BigDecimal.ZERO)
                pedidoCompra.setTdesconto_valor(BigDecimal.ZERO)
                pedidoCompra.setTobs("")
                pedidoCompra.setTqtde_itens_merc(1)
                pedidoCompra.setTsaldo_a_entregar(valor)
                pedidoCompra.setTstatus_pedido_chk("A")
                pedidoCompra.setTunidade_fk(cotacao.getTunidade_fk())
                pedidoCompra.setTusuario_comprador_fk(1);   //TEM DE SETAR ESSE VALOR CORRETAMENTE DANDO UM JEITO DE PEGAR O USUÁRIO LOGADO
                pedidoCompra.setTvalor_bruto(valor)
                pedidoCompra.setTvalor_liquido_pedido(valor)
                pedidoCompra.setTvalor_pedido(valor)
                ArrayList<PedidoCompraItem> itensPedido = new ArrayList<PedidoCompraItem>();
                itensPedido.add(item);

                pedidoCompra.setPedidoCompraItemList(itensPedido)
                map.put(codFornecedor, pedidoCompra);
            }
        }

        return map;
    }
}